home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / plane / _segment.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  4.9 KB  |  243 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  _segment.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16.  
  17. #include <LEDA/line.h>
  18. #include <math.h>
  19. #include <ctype.h>
  20.  
  21. static const double eps = 1e-10;
  22.  
  23.  
  24. //------------------------------------------------------------------------------
  25. // segments 
  26. //------------------------------------------------------------------------------
  27.  
  28. segment_rep::segment_rep()  { count = 1; }
  29.  
  30. segment_rep::segment_rep(const point& p, const point& q) 
  31. { start = p;
  32.   end   = q;
  33.   count = 1; 
  34.  
  35.   double dx = q.xcoord() - p.xcoord(); 
  36.   double dy = q.ycoord() - p.ycoord(); 
  37.  
  38.   if (dy==0)
  39.      slope = 0;
  40.   else
  41.      if (dx==0)
  42.        slope = MAXDOUBLE;
  43.      else
  44.        slope = dy/dx;
  45.  
  46.  
  47.   if (slope == MAXDOUBLE)
  48.      y_abs = -MAXDOUBLE;
  49.   else
  50.      y_abs =  p.ycoord() - slope * p.xcoord();
  51.  
  52.  
  53.   if (dx != 0 || dy != 0)
  54.       angle = atan2(dy,dx); 
  55.   else
  56.       angle = 0;
  57.  
  58. /*
  59.   angle = 0;
  60.   if (dx != 0 || dy != 0) 
  61.   { double cosfi=dx/sqrt(dx*dx+dy*dy);
  62.   
  63.     if (cosfi >=  1.0 ) 
  64.        angle = 0;
  65.     else
  66.       if (cosfi <= -1.0 ) 
  67.          angle = -M_PI;
  68.       else
  69.          angle = -acos(cosfi);
  70.  
  71.     if (dy > 0) angle = -angle;
  72.   }
  73. */
  74.     
  75. }
  76.   
  77.  
  78.  
  79. segment::segment() { PTR = new segment_rep; }
  80. segment::segment(const point& x, const point& y) { PTR = new segment_rep(x,y); }
  81. segment::segment(double x1, double y1, double x2, double y2) 
  82.                           { PTR = new segment_rep(point(x1,y1), point(x2,y2)); }
  83.  
  84. segment::segment(const point& p, double alpha, double length)
  85. { point q = p.translate(alpha,length);
  86.   PTR  = new segment_rep(p,q); 
  87.  }
  88.   
  89.  
  90. segment segment::translate(double alpha, double d) const
  91. { point p = ptr()->start.translate(alpha,d);
  92.   point q = ptr()->end.translate(alpha,d);
  93.   return segment(p,q);
  94.  }
  95.  
  96. segment segment::translate(const vector& v) const
  97. { point p = ptr()->start.translate(v);
  98.   point q = ptr()->end.translate(v);
  99.   return segment(p,q);
  100.  }
  101.  
  102.  
  103. ostream& operator<<(ostream& out, const segment& s) 
  104. { out << "[" << s.start() << "===" << s.end() << "]"; 
  105.   return out;
  106.  } 
  107.  
  108. /*
  109. istream& operator>>(istream& in, segment& s) 
  110. { double x1,x2,y1,y2; 
  111.   in >> x1 >> y1 >> x2 >> y2; 
  112.   s = segment(x1,y1,x2,y2); 
  113.   return in; 
  114.  } 
  115. */
  116.  
  117. istream& operator>>(istream& in, segment& s) 
  118. { // syntax: {[} p {===} q {]}
  119.  
  120.   point p,q; 
  121.   char c;
  122.  
  123.   do in.get(c); while (isspace(c));
  124.   if (c != '[') in.putback(c);
  125.  
  126.   in >> p;
  127.  
  128.   do in.get(c); while (isspace(c));
  129.   while (c== '=') in.get(c);
  130.   while (isspace(c)) in.get(c);
  131.   in.putback(c);
  132.  
  133.   in >> q; 
  134.  
  135.   do in.get(c); while (c == ' ');
  136.   if (c != ']') in.putback(c);
  137.  
  138.   s = segment(p,q); 
  139.   return in; 
  140.  
  141.  } 
  142.  
  143.  
  144.  
  145.  
  146. double segment::angle(const segment& s) const
  147. {
  148.   double cosfi,fi,norm;
  149.   
  150.   double dx  = ptr()->end.ptr()->x - ptr()->start.ptr()->x; 
  151.   double dy  = ptr()->end.ptr()->y - ptr()->start.ptr()->y; 
  152.  
  153.   double dxs = s.ptr()->end.ptr()->x - s.ptr()->start.ptr()->x; 
  154.   double dys = s.ptr()->end.ptr()->y - s.ptr()->start.ptr()->y; 
  155.   
  156.   cosfi=dx*dxs+dy*dys;
  157.   
  158.   norm=(dx*dx+dy*dy)*(dxs*dxs+dys*dys);
  159.  
  160.   if (norm == 0) return 0;
  161.  
  162.   cosfi /= sqrt( norm );
  163.  
  164.   if (cosfi >=  1.0 ) return 0;
  165.   if (cosfi <= -1.0 ) return M_PI;
  166.   
  167.   fi=acos(cosfi);
  168.  
  169.   if (dx*dys-dy*dxs>0) return fi;
  170.  
  171.   return -fi;
  172.  
  173. }
  174.  
  175.  
  176. double segment::distance(const segment& s) const
  177. { if (angle(s)!=0) return 0;
  178.   return distance(s.ptr()->start);
  179.  }
  180.  
  181. double  segment::distance() const
  182. { return distance(point(0,0)); }
  183.  
  184. double segment::distance(const point& p) const
  185. { segment s(ptr()->start,p);
  186.   double l = s.length();
  187.   if (l==0) return 0;
  188.   else return l*sin(angle(s));
  189.  }
  190.  
  191.  
  192. double  segment::y_proj(double x)  const
  193. { return  ptr()->start.ptr()->y - ptr()->slope * (ptr()->start.ptr()->x - x); }
  194.  
  195. double  segment::x_proj(double y)  const
  196. { if (vertical())  return  ptr()->start.ptr()->x;
  197.   return  ptr()->start.ptr()->x - (ptr()->start.ptr()->y - y)/ptr()->slope; }
  198.  
  199.  
  200.  
  201. bool segment::intersection(const segment& s, point& inter) const
  202. { double cx,cy;
  203.  
  204.   if (slope() == s.slope()) return false;
  205.  
  206.   if (vertical())
  207.      cx = xcoord1();
  208.   else
  209.      if (s.vertical())
  210.         cx = s.xcoord1();
  211.      else
  212.         cx = (s.y_abs()-y_abs())/(slope()-s.slope());
  213.  
  214.   if(xcoord1() < cx &&  xcoord2()  < cx ||  xcoord1() > cx  && xcoord2() > cx ||
  215.    s.xcoord1() < cx && s.xcoord2() < cx || s.xcoord1() > cx && s.xcoord2() > cx)
  216.   return false;
  217.  
  218.   if (vertical())
  219.      cy = s.slope() * cx + s.y_abs();
  220.   else
  221.      cy = slope() * cx + y_abs();
  222.  
  223.   inter = point(cx,cy);
  224.  
  225.   return true;
  226. }
  227.  
  228.  
  229. segment segment::rotate(double alpha) const
  230. {  double  l = length();
  231.    point p = start();
  232.    double beta = alpha + angle();
  233.    return segment(p,beta,l);
  234. }
  235.  
  236. segment segment::rotate(const point& origin, double alpha) const
  237. {  point p = start().rotate(origin,alpha);
  238.    point q = end().rotate(origin,alpha);
  239.    return segment(p,q);
  240. }
  241.  
  242.  
  243.